MAY, 1994
Author: Rick Greenwald
Gupta Corporation
1060 Marsh Road
Menlo Park, CA 94025
April 1994
All trademarks, trade names and product names are registered trademarks or trademarks of their respective holders.
Copyright 1994, Gupta Corporation.
All rights reserved.
Information in this document may change without notice.
Would you like to be able to create a robust master-detail application by simply clicking on selection boxes five times?
Would you like to enable your applications to send and receive mail with only three mouse clicks?
Would you like to produce your first complete application in the first hour you use your new development tool?
QuickObjects are a new addition to Gupta's powerful SQLWindows application development environment that allows you to accomplish all this - and more.
Since its introduction in 1988, Gupta's SQLWindows has been the most powerful development environment for creating graphical client/server applications. Gupta is now complementing this power with an easy new architecture for creating applications called QuickObjects. This paper will describe the purpose of QuickObjects, the components of the QuickObject architecture, the way these components can be used in a development environment, some of the main benefits of QuickObjects, and look to the future of QuickObjects.
More and more organizations are moving to a client/server computing environment. The move to client/server has imposed two pressures on developers. The move to a new environment has forced developers to rapidly create robust applications for the client/server environment. At the same time, the client/server environment is new to many developers, so they are faced with the challenge of quickly learning how to create robust client/server applications. This situation creates a great deal of pressure for developers to begin creating client/server applications without spending too much time learning a new development tool.
QuickObjects are reusable components that contain all the intelligence necessary to insulate the developer from the need to write code to create client/server applications. Their purpose is to speed up development and reduce the amount of testing necessary by providing components with proven functionality.
Gupta has provided the QuickObject architecture to reduce the time needed for new client/server developers to be productive. At the same time, QuickObjects do not compromise the flexibility that experienced developers need to create large scale applications. The QuickObject architecture does this by creating an intuitive architecture that is powerful and extensible.
QuickObjects provide high-level objects for creating client/server applications. These objects are easy to learn because they allow a developer to create applications without coding. QuickObjects are powerful because they allow developers to modify existing QuickObjects and create their own QuickObjects within SQLWindows' object-oriented environment. QuickObjects also allow a developer to easily extend the QuickObjects with the logic specific to a particular client/server application. Each QuickObject component is independent, yet the interaction between the components is specific. This allows the QuickObjects, whether they are used in their standard or extended form, whether they are supplied by Gupta or created by a third party, to be used in the same easy to learn and use manner.
QuickObjects are part of the continuing evolution of Gupta's Tools Integration Environment (TIE) strategy. SQLWindows has been created from the ground up to include the ability to integrate outside libraries and to use a complete object orientation to rapidly create robust applications that can be easily maintained. The QuickObject architecture is built on these capabilities, and expands their reach by providing an easy way to use and integrate objects within the QuickObject architecture.
QuickObjects contain all the intelligence necessary to insulate the developer from the need to write code to create client/server applications. Their purpose is to both speed up development and to reduce the amount of testing necessary by providing components with built-in functionality.
For example, in traditional fourth-generation languages, a developer would create a group of radio buttons by first creating the group, then creating an individual radio button for each value represented in the group, then writing code to enable the proper functioning of the radio buttons. This is not only time-consuming, but it requires the developer to know about the data structures used, the data values those structures contain, and to spend time insuring that the code written works properly.
With QuickObjects, a developer can simply indicate that a group of radio buttons is desired. The QuickObject development environment will present the developer with a list of viable data elements. When the developer chooses a particular element, the QuickObject gathers the information necessary and creates the entire group of radio buttons, which work in the desired manner. The intelligence to accomplish this is built into the QuickObjects. The use of QuickObjects speeds up development of client/server applications and reduce the opportunities for defects to appear.
There are three types of QuickObjects, which correspond to the three major components of a client-server architecture: data access, user interface and user-driven functionality.
The first type of QuickObject is the QuickObject data source. This is a highly capable object that controls all aspects of the interaction between the client application and the data. This interaction includes
For instance, a QuickObject data source knows how and when to establish an initial connection with the data it accesses, how to navigate through that data in response to user commands, and what user commands are appropriate for the data it accesses. Most of the intelligence in the application is located in the QuickObject data source. QuickObject data sources can work for traditional sources of data, such as relational tables or views, or non-traditional sources of data, such as a mail system, fields in a 3270 application, data in a Lotus Notes database or traditional PC databases.
The second type of QuickObject is the QuickObject visualizer. This is a QuickObject that controls the presentation of the server data to the user and any changes the user might make to the data. Examples of QuickObject visualizers are data fields, list boxes, combo boxes or radio buttons. A QuickObject visualizer is associated with a particular data source at design time. This simplifies the development effort, since a QuickObject visualizer is the same for any QuickObject data source, regardless of what type of data the QuickObject data source is accessing.
The third type of QuickObject is the QuickObject commander. This is a QuickObject that directs user commands to the QuickObject data source. A QuickObject commander controls how the QuickObject data source accesses and modifies its associated data. The visual representation of a commander is generally a pushbutton. An application might contain pushbuttons for movement through database records, such as 'First' and 'Last' pushbuttons. The appearance of the commander is dictated by the command that the QuickObject commander represents. This simplifies the development effort, since a single type of QuickObject commander can handle any and all commands for a particular QuickObject data source.
In addition to providing the ability to create applications using QuickObjects, SQLWindows 5.0 also includes a wizard-like functionality called QuickForms. QuickForms walk a developer through the steps of creating a complete form. A developer can choose the tables the application uses, and then select the columns from the tables that are desired in the application. QuickForms can then create the entire application with the appropriate QuickObjects visualizers and commanders. A developer can have a working client-server application in a matter of minutes! QuickForms not only speed up the development of an application, but it also sharply decreases the learning curve for a beginning SQLWindows developer. With QuickForms, even developers who have never worked in a client-server environment can create powerful applications quickly.
A SQLWindows developer can easily create an application using QuickObjects in three easy steps.
Step 1: The developer begins by selecting a QuickObject data source from the SQLWindows tool palette. Once the QuickObject data source is selected, the SQLWindows tool palette offers the developer choices as to the configuration of a particular data source, such as which table or view in which relational database will be associated with the data source.
Step 2: The developer can then select any of a number of QuickObject visualizers from the tool palette. Once the QuickObject visualizer is selected, the SQLWindows tool palette offers the developer a list of available QuickObject data sources. The QuickObject visualizer will use information from the Gupta Open Repository to configure itself to the appropriate length, data type and other extended attributes. The developer is able to further configure the QuickObject visualizer, if desired.
A developer can drop QuickObject visualizers into a form one at a time, or place multiple QuickObject visualizers into the form at the same time. The developer can also easily add validation rules to a QuickObject visualizer to ensure that data entered through the QuickObject visualizer conforms to the values allowed.
Step 3: The developer can also select a QuickObject commander from the tool palette. Once the QuickObject commander is selected, the SQLWindows tools palette offers the developer a list of available QuickObject data sources. After a QuickObject data source is selected, SQLWindows presents a list of commands that are available for the selected QuickObject data source. The QuickObject commander automatically configures itself with the appropriate title and bitmap for a particular command.
This will create the bulk of a SQLWindows application. At this point, the developer can use the powerful SQLWindows development environment to add additional application logic to the application, if desired.
A developer can also use QuickForms to create an application. QuickForms will walk the developer through the steps outlined above by presenting the developer with a series of choices that emulate this process.
QuickObjects provide three basic benefits to developers: rapid learning and development of client/server applications, increased power in the SQLWindows environment and the ability to integrate heterogeneous data into a single form or application.
QuickObjects provide an easy way to learn and develop client/server applications with SQLWindows. A developer can choose a QuickObject data source, drop some QuickObject visualizers and commanders into the application, and have a working client/server application within minutes. QuickForms provide a means of developing an application where a developer is guided through the development process and create applications with just a few mouse clicks.
The QuickObject architecture also makes it very easy for developers to add additional QuickObjects into their development environment while still using the same framework for creating applications. A QuickObject data source for electronic mail is used in the same manner as a QuickObject data source for relational data. A QuickObject visualizer works the same way for either source. A QuickObject commander is used in the same way for any data source. QuickObjects make SQLWindows easier to learn, easier to use and easier to extend with the addition of other QuickObjects in the future.
The QuickObject architecture also provides more power for SQLWindows developers. A great deal of the intelligence of an application is included in the QuickObjects used to build the application. QuickObjects can not only provide a way to develop basic applications, but can include sophisticated logic and processing.
Although QuickObjects provide an easy way to create applications without coding, the QuickObjects architecture does not limit the power of client-server applications by hiding the workings of the application in a 'black box'. QuickObjects provide an easy way for developers to extend their functionality. When a developer uses a QuickObject in a SQLWindows application, the QuickObject becomes part of the application, with all of the QuickObject code visible and accessible. A developer can supplement the inherent QuickObject functionality within the SQLWindows environment by using the standard SQLWindows functions.
A QuickObject is also an instance of a QuickObject class, so it can be extended in the same way that additional functionality can be added to any SQLWindows class. A developer can choose to extend the functionality of a single instance of a QuickObject, or all of the instances of a particular QuickObject. A developer can also create new QuickObject classes that automatically inherit additional functionality.
This gives QuickObjects the unique advantage of being able to provide an easy way to develop applications, while still retaining the power and flexibility of SQLWindows.
Finally, SQLWindows developers can easily create new QuickObjects, or convert their existing classes and class libraries into QuickObjects. A developer can also create a dialog box to act as the design-time interface to a QuickObject without any coding. This gives SQLWindows developers the ability to extend the SQLWindows environment in a manner that is best suited to the particular type of QuickObject they are creating.
The QuickObject architecture provides a way to easily integrate heterogeneous sources of data. A developer can include and link data from different relational data sources, or from non-relational data sources, such as electronic mail or Lotus Notes, by simply including a QuickObject data source for each type of data. The QuickObject visualizers and commanders can be assign to either data source within the context of a single screen or application. The differences in how the sources of data are accessed and manipulated are handled by the QuickObjects, so the developer does not have to worry about these differences.
The QuickObject architecture allow developers to easily integrate QuickObjects that they design. A developer can create QuickObject components entirely within the SQLWindows environment and use these QuickObjects in other applications.
The QuickObject architecture also provides some unified high-level functionality, such as error-handling, for all QuickObjects. This allows a developer to configure the functionality of the entire QuickObject application with a single option, such as whether and how to inform users of errors, whether to log the errors to a file, or any combination of error handling.
QuickObjects provide more than a collection of components that can dramatically reduce a developer's learning curve and increase a developer's productivity. QuickObjects also provide an architecture for development in the powerful and robust SQLWindows environment. This opens the way for dramatic advances in the power and capabilities provided by QuickObjects.
Shortly, QuickObject data sources will be available that will access additional non-relational data sources. A SQLWindows developer will be able to use QuickObject data sources to utilize data from traditional mainframe data sources, such as 3270 screens, in their applications. QuickObjects will also be introduced that allow developers to use the services provided by transaction processing monitors, such as TUXEDO, to act as a QuickObject data source.
QuickObjects will also expand the functionality that they offer to developers. QuickObject data sources will provide more than access to data. The QuickObject architecture will allow developers to create robust applications by interacting with robust QuickObjects that run off a set of user-defined business rules. A developer could use the QuickObject architecture to simply describe how an application will interact with a set of business rules, and the QuickObject will properly implement the complex logic in the application. QuickObjects will also give developers access to capabilities such as work-flow management.
QuickObjects will also be extended and created by SQLWindows developers around the world. The ease with which developers can create QuickObjects and integrate them into the existing QuickObject architecture will allow hundreds of QuickObjects, from powerful logic providers to vertical application specific objects, to become available within the coming months.
Proficient SQLWindows programmers will be able to become QuickObject engineers. Their ability to create powerful business objects will be easily passed on to a large number of QuickObject integrators, who will be able to take advantage of the encapsulated functionality in QuickObjects to create powerful applications within easy-to-use QuickObject architecture. This will allow all client/server developers to become as powerful as the most senior programmers, while creating applications as easily and rapidly as necessary for the least experienced developer.